// SkeletonTest_Interface.java : behavior editor generated Java class
package com.stottlerhenke.simbionic.test.engine.basic;

import com.stottlerhenke.simbionic.api.*;
import java.util.ArrayList;

public class SkeletonTest_Interface extends SB_Interface
{
// sim revision number
	public static final int SIM_REV = 34;

// actions
	public static final int ACTION_Print = 128;
	public static final int ACTION_TestAnyAct = 129;
	public static final int ACTION_TestArrayAct = 130;
	public static final int ACTION_TestBoolAct = 131;
	public static final int ACTION_TestDataAct = 137;
	public static final int ACTION_TestEntityAct = 138;
	public static final int ACTION_TestFloatAct = 133;
	public static final int ACTION_TestIntAct = 132;
	public static final int ACTION_TestStringAct = 136;
	public static final int ACTION_TestTableAct = 135;
	public static final int ACTION_TestVectorAct = 134;

// predicates
	public static final int PRED_GetBoolConst = 139;
	public static final int PRED_GetFloatConst = 140;
	public static final int PRED_GetIntConst = 141;
	public static final int PRED_GetStringConst = 142;
	public static final int PRED_GetVectorConst = 143;
	public static final int PRED_TestAny = 138;
	public static final int PRED_TestArray = 134;
	public static final int PRED_TestBool = 131;
	public static final int PRED_TestData = 137;
	public static final int PRED_TestEntity = 136;
	public static final int PRED_TestFloat = 130;
	public static final int PRED_TestInt = 128;
	public static final int PRED_TestReturn = 129;
	public static final int PRED_TestString = 133;
	public static final int PRED_TestTable = 135;
	public static final int PRED_TestVector = 132;

	public SkeletonTest_Interface()
	{
	}

	public String getModuleName()
	{
		return "SkeletonTest";
	}

	public ArrayList getModuleActions()
	{
		ArrayList actions = new ArrayList();

		SB_FuncSpec fs;
		SB_FuncParamSpec fps;
		ArrayList params;

		// Print
		params = new ArrayList();
		fps = new SB_FuncParamSpec("message", SB_ParamDir.kIn, SB_VarType.kString);
		params.add(fps);
		fs = new SB_FuncSpec("Print", 128, SB_VarType.kVoid, params);
		actions.add(fs);

		// TestAnyAct
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kAny);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kAny);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kAny);
		params.add(fps);
		fs = new SB_FuncSpec("TestAnyAct", 129, SB_VarType.kVoid, params);
		actions.add(fs);

		// TestArrayAct
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kArray);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kArray);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kArray);
		params.add(fps);
		fs = new SB_FuncSpec("TestArrayAct", 130, SB_VarType.kVoid, params);
		actions.add(fs);

		// TestBoolAct
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kBoolean);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kBoolean);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kBoolean);
		params.add(fps);
		fs = new SB_FuncSpec("TestBoolAct", 131, SB_VarType.kVoid, params);
		actions.add(fs);

		// TestDataAct
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kData);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kData);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kData);
		params.add(fps);
		fs = new SB_FuncSpec("TestDataAct", 137, SB_VarType.kVoid, params);
		actions.add(fs);

		// TestEntityAct
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kEntity);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kEntity);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kEntity);
		params.add(fps);
		fs = new SB_FuncSpec("TestEntityAct", 138, SB_VarType.kVoid, params);
		actions.add(fs);

		// TestFloatAct
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kFloat);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kFloat);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kFloat);
		params.add(fps);
		fs = new SB_FuncSpec("TestFloatAct", 133, SB_VarType.kVoid, params);
		actions.add(fs);

		// TestIntAct
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kInteger);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kInteger);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kInteger);
		params.add(fps);
		fs = new SB_FuncSpec("TestIntAct", 132, SB_VarType.kVoid, params);
		actions.add(fs);

		// TestStringAct
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kString);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kString);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kString);
		params.add(fps);
		fs = new SB_FuncSpec("TestStringAct", 136, SB_VarType.kVoid, params);
		actions.add(fs);

		// TestTableAct
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kArray);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kArray);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kArray);
		params.add(fps);
		fs = new SB_FuncSpec("TestTableAct", 135, SB_VarType.kVoid, params);
		actions.add(fs);

		// TestVectorAct
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kVector);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kVector);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kVector);
		params.add(fps);
		fs = new SB_FuncSpec("TestVectorAct", 134, SB_VarType.kVoid, params);
		actions.add(fs);

		return actions;
	}

	public ArrayList getModulePredicates()
	{
		ArrayList preds = new ArrayList();

		SB_FuncSpec fs;
		SB_FuncParamSpec fps;
		ArrayList params;

		// GetBoolConst : boolean
		params = new ArrayList();
		fs = new SB_FuncSpec("GetBoolConst", 139, SB_VarType.kBoolean, params);
		preds.add(fs);

		// GetFloatConst : float
		params = new ArrayList();
		fs = new SB_FuncSpec("GetFloatConst", 140, SB_VarType.kFloat, params);
		preds.add(fs);

		// GetIntConst : integer
		params = new ArrayList();
		fs = new SB_FuncSpec("GetIntConst", 141, SB_VarType.kInteger, params);
		preds.add(fs);

		// GetStringConst : string
		params = new ArrayList();
		fs = new SB_FuncSpec("GetStringConst", 142, SB_VarType.kString, params);
		preds.add(fs);

		// GetVectorConst : vector
		params = new ArrayList();
		fs = new SB_FuncSpec("GetVectorConst", 143, SB_VarType.kVector, params);
		preds.add(fs);

		// TestAny : boolean
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kAny);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kAny);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kAny);
		params.add(fps);
		fs = new SB_FuncSpec("TestAny", 138, SB_VarType.kBoolean, params);
		preds.add(fs);

		// TestArray : boolean
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kArray);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kArray);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kArray);
		params.add(fps);
		fs = new SB_FuncSpec("TestArray", 134, SB_VarType.kBoolean, params);
		preds.add(fs);

		// TestBool : boolean
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kBoolean);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kBoolean);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kBoolean);
		params.add(fps);
		fs = new SB_FuncSpec("TestBool", 131, SB_VarType.kBoolean, params);
		preds.add(fs);

		// TestData : boolean
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kData);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kData);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kData);
		params.add(fps);
		fs = new SB_FuncSpec("TestData", 137, SB_VarType.kBoolean, params);
		preds.add(fs);

		// TestEntity : boolean
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kEntity);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kEntity);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kEntity);
		params.add(fps);
		fs = new SB_FuncSpec("TestEntity", 136, SB_VarType.kBoolean, params);
		preds.add(fs);

		// TestFloat : boolean
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kFloat);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kFloat);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kFloat);
		params.add(fps);
		fs = new SB_FuncSpec("TestFloat", 130, SB_VarType.kBoolean, params);
		preds.add(fs);

		// TestInt : boolean
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kInteger);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kInteger);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kInteger);
		params.add(fps);
		fs = new SB_FuncSpec("TestInt", 128, SB_VarType.kBoolean, params);
		preds.add(fs);

		// TestReturn : string
		params = new ArrayList();
		fps = new SB_FuncParamSpec("returnValue", SB_ParamDir.kIn, SB_VarType.kString);
		params.add(fps);
		fs = new SB_FuncSpec("TestReturn", 129, SB_VarType.kString, params);
		preds.add(fs);

		// TestString : boolean
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kString);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kString);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kString);
		params.add(fps);
		fs = new SB_FuncSpec("TestString", 133, SB_VarType.kBoolean, params);
		preds.add(fs);

		// TestTable : boolean
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kArray);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kArray);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kArray);
		params.add(fps);
		fs = new SB_FuncSpec("TestTable", 135, SB_VarType.kBoolean, params);
		preds.add(fs);

		// TestVector : boolean
		params = new ArrayList();
		fps = new SB_FuncParamSpec("p1", SB_ParamDir.kIn, SB_VarType.kVector);
		params.add(fps);
		fps = new SB_FuncParamSpec("p2", SB_ParamDir.kOut, SB_VarType.kVector);
		params.add(fps);
		fps = new SB_FuncParamSpec("p3", SB_ParamDir.kInOut, SB_VarType.kVector);
		params.add(fps);
		fs = new SB_FuncSpec("TestVector", 132, SB_VarType.kBoolean, params);
		preds.add(fs);

		return preds;
	}

	public String getActionName(int actionId)
	{
		switch (actionId)
		{
		case ACTION_Print:
			return "Print";
		case ACTION_TestAnyAct:
			return "TestAnyAct";
		case ACTION_TestArrayAct:
			return "TestArrayAct";
		case ACTION_TestBoolAct:
			return "TestBoolAct";
		case ACTION_TestDataAct:
			return "TestDataAct";
		case ACTION_TestEntityAct:
			return "TestEntityAct";
		case ACTION_TestFloatAct:
			return "TestFloatAct";
		case ACTION_TestIntAct:
			return "TestIntAct";
		case ACTION_TestStringAct:
			return "TestStringAct";
		case ACTION_TestTableAct:
			return "TestTableAct";
		case ACTION_TestVectorAct:
			return "TestVectorAct";
		default:
			// unknown action
			return "";
		}
	}

	public String getPredicateName(int predId)
	{
		switch (predId)
		{
		case PRED_GetBoolConst:
			return "GetBoolConst";
		case PRED_GetFloatConst:
			return "GetFloatConst";
		case PRED_GetIntConst:
			return "GetIntConst";
		case PRED_GetStringConst:
			return "GetStringConst";
		case PRED_GetVectorConst:
			return "GetVectorConst";
		case PRED_TestAny:
			return "TestAny";
		case PRED_TestArray:
			return "TestArray";
		case PRED_TestBool:
			return "TestBool";
		case PRED_TestData:
			return "TestData";
		case PRED_TestEntity:
			return "TestEntity";
		case PRED_TestFloat:
			return "TestFloat";
		case PRED_TestInt:
			return "TestInt";
		case PRED_TestReturn:
			return "TestReturn";
		case PRED_TestString:
			return "TestString";
		case PRED_TestTable:
			return "TestTable";
		case PRED_TestVector:
			return "TestVector";
		default:
			// unknown predicate
			return "";
		}
	}

	public void doAction(int actionId, long entityId, ArrayList params) throws SB_Exception
	{
		switch (actionId)
		{
		case ACTION_Print:
			Print((SB_Param)params.get(0));
			break;
		case ACTION_TestAnyAct:
			TestAnyAct((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
			break;
		case ACTION_TestArrayAct:
			TestArrayAct((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
			break;
		case ACTION_TestBoolAct:
			TestBoolAct((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
			break;
		case ACTION_TestDataAct:
			TestDataAct((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
			break;
		case ACTION_TestEntityAct:
			TestEntityAct((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
			break;
		case ACTION_TestFloatAct:
			TestFloatAct((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
			break;
		case ACTION_TestIntAct:
			TestIntAct((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
			break;
		case ACTION_TestStringAct:
			TestStringAct((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
			break;
		case ACTION_TestTableAct:
			TestTableAct((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
			break;
		case ACTION_TestVectorAct:
			TestVectorAct((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
			break;
		default:
			// unknown action
			break;
		}
	}

	public SB_Param doPredicate(int predId, long entityId, ArrayList params) throws SB_Exception
	{
		switch (predId)
		{
		case PRED_GetBoolConst:
			return GetBoolConst();
		case PRED_GetFloatConst:
			return GetFloatConst();
		case PRED_GetIntConst:
			return GetIntConst();
		case PRED_GetStringConst:
			return GetStringConst();
		case PRED_GetVectorConst:
			return GetVectorConst();
		case PRED_TestAny:
			return TestAny((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
		case PRED_TestArray:
			return TestArray((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
		case PRED_TestBool:
			return TestBool((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
		case PRED_TestData:
			return TestData((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
		case PRED_TestEntity:
			return TestEntity((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
		case PRED_TestFloat:
			return TestFloat((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
		case PRED_TestInt:
			return TestInt((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
		case PRED_TestReturn:
			return TestReturn((SB_Param)params.get(0));
		case PRED_TestString:
			return TestString((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
		case PRED_TestTable:
			return TestTable((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
		case PRED_TestVector:
			return TestVector((SB_Param)params.get(0), (SB_Param)params.get(1), (SB_Param)params.get(2));
		default:
			// unknown predicate
			return new SB_Param();
		}
	}

	// ---- Action Implementations

	/**
	 * Prints the specified
	 * @param message : string [in]
	 */
	void Print(SB_Param message) throws SB_Exception
	{
		System.out.println(message);
	}

	/**
	 * Tests that "any" parameters are handled properly by action code
	 * generation.
	 * @param p1 : any [in]
	 * @param p2 : any [out]
	 * @param p3 : any [in/out]
	 */
	void TestAnyAct(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		// your TestAnyAct implementation here
	}

	/**
	 * Tests that array parameters are handled properly by action code
	 * generation.
	 * @param p1 : array [in]
	 * @param p2 : array [out]
	 * @param p3 : array [in/out]
	 */
	void TestArrayAct(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		// your TestArrayAct implementation here
	}

	/**
	 * Tests that boolean parameters are handled properly by action
	 * code
	 * @param p1 : boolean [in]
	 * @param p2 : boolean [out]
	 * @param p3 : boolean [in/out]
	 */
	void TestBoolAct(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		// your TestBoolAct implementation here
	}

	/**
	 * Tests that data parameters are handled properly by action code
	 * generation.
	 * @param p1 : data [in]
	 * @param p2 : data [out]
	 * @param p3 : data [in/out]
	 */
	void TestDataAct(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		// your TestDataAct implementation here
	}

	/**
	 * Tests that entity parameters are handled properly by action code
	 * generation.
	 * @param p1 : entity [in]
	 * @param p2 : entity [out]
	 * @param p3 : entity [in/out]
	 */
	void TestEntityAct(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		// your TestEntityAct implementation here
	}

	/**
	 * Tests that float parameters are handled properly by action code
	 * generation.
	 * @param p1 : float [in]
	 * @param p2 : float [out]
	 * @param p3 : float [in/out]
	 */
	void TestFloatAct(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		// your TestFloatAct implementation here
	}

	/**
	 * Tests that integer parameters are handled properly by action
	 * code
	 * @param p1 : integer [in]
	 * @param p2 : integer [out]
	 * @param p3 : integer [in/out]
	 */
	void TestIntAct(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		// your TestIntAct implementation here
	}

	/**
	 * Tests that string parameters are handled properly by action code
	 * generation.
	 * @param p1 : string [in]
	 * @param p2 : string [out]
	 * @param p3 : string [in/out]
	 */
	void TestStringAct(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		// your TestStringAct implementation here
	}

	/**
	 * Tests that table parameters are handled properly by action code
	 * generation.
	 * @param p1 : table [in]
	 * @param p2 : table [out]
	 * @param p3 : table [in/out]
	 */
	void TestTableAct(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		// your TestTableAct implementation here
	}

	/**
	 * Tests that vector parameters are handled properly by action code
	 * generation.
	 * @param p1 : vector [in]
	 * @param p2 : vector [out]
	 * @param p3 : vector [in/out]
	 */
	void TestVectorAct(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		// your TestVectorAct implementation here
	}

	// ---- Predicate Implementations

	/**
	 * Returns the value of CONST_BOOL from the
	 * @return boolean
	 */
	SB_Param GetBoolConst() throws SB_Exception
	{
		// your GetBoolConst implementation here
		return new SB_Param( SkeletonTest_Constants.CONST_BOOL );
	}

	/**
	 * Returns the value of CONST_FLOAT from the
	 * @return float
	 */
	SB_Param GetFloatConst() throws SB_Exception
	{
		// your GetFloatConst implementation here
		return new SB_Param( SkeletonTest_Constants.CONST_FLOAT );
	}

	/**
	 * Returns the value of CONST_INT from the
	 * @return integer
	 */
	SB_Param GetIntConst() throws SB_Exception
	{
		// your GetIntConst implementation here
		return new SB_Param( SkeletonTest_Constants.CONST_INT );
	}

	/**
	 * Returns the value of CONST_STRING from the
	 * @return string
	 */
	SB_Param GetStringConst() throws SB_Exception
	{
		// your GetStringConst implementation here
		return new SB_Param( SkeletonTest_Constants.CONST_STRING );
	}

	/**
	 * Returns the value of CONST_VECTOR from the
	 * @return vector
	 */
	SB_Param GetVectorConst() throws SB_Exception
	{
		// your GetVectorConst implementation here
		return new SB_Param( SkeletonTest_Constants.CONST_VECTOR );
	}

	/**
	 * Tests that "any" parameters are properly
	 * @param p1 : any [in]
	 * @param p2 : any [out]
	 * @param p3 : any [in/out]
	 * @return boolean
	 */
	SB_Param TestAny(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		p2.setString( "out" );

		boolean p3Value = false;
		if ((p3.getType() == SB_ParamType.kSB_String) && (p3.getString().compareTo("in") == 0))
			p3Value = true;

		p3.setString("out");

		if (((p1.getType() == SB_ParamType.kSB_String) && (p1.getString().compareTo("in") == 0)) && p3Value)
			return new SB_Param(true);
		return new SB_Param(false);
	}

	/**
	 * Tests that array parameters are properly
	 * @param p1 : array [in]
	 * @param p2 : array [out]
	 * @param p3 : array [in/out]
	 * @return boolean
	 */
	SB_Param TestArray(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		p2.setArraySize(0);
		p2.arrayAdd(new SB_Param(1));
		p2.arrayAdd(new SB_Param(2));

		boolean p3Value = false;
		if ((p3.getArrayEntry(0).getInteger()==10) &&
			(p3.getArrayEntry(1).getInteger()==20) &&
			(p3.getArrayEntry(2).getInteger()==30))
			p3Value = true;

		p3.setArraySize(0);
		p3.arrayAdd(new SB_Param(1));
		p3.arrayAdd(new SB_Param(2));

		if (p3Value
			&& (p1.getArrayEntry(0).getInteger()==10)
			&& (p1.getArrayEntry(1).getInteger()==20)
			&& (p1.getArrayEntry(2).getInteger()==30))
			return new SB_Param(true);
		return new SB_Param(false);
	}

	/**
	 * Tests that boolean parameters are properly
	 * @param p1 : boolean [in]
	 * @param p2 : boolean [out]
	 * @param p3 : boolean [in/out]
	 * @return boolean
	 */
	SB_Param TestBool(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		p2.setBoolean(false);

		boolean p3Value = p3.getBoolean();
		p3.setBoolean(false);

		if (p1.getBoolean() && p3Value)
			return new SB_Param(true);
		return new SB_Param(false);
	}

	/**
	 * Tests that data parameters are properly
	 * @param p1 : data [in]
	 * @param p2 : data [out]
	 * @param p3 : data [in/out]
	 * @return boolean
	 */
	SB_Param TestData(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		p2.setData(new Integer(5));

		boolean p3Value = (p3.getData() == null);
		p3.setData(p2.getData());

		if ((p1.getData()==null) && p3Value)
			return new SB_Param(true);
		return new SB_Param(false);
	}

	/**
	 * Tests that entity parameters are properly
	 * @param p1 : entity [in]
	 * @param p2 : entity [out]
	 * @param p3 : entity [in/out]
	 * @return boolean
	 */
	SB_Param TestEntity(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		p2.setEntity(SB_Param.INVALID_ID);

		boolean equal = (p3.getEntity() == p1.getEntity());
		p3.setEntity(SB_Param.INVALID_ID);

		if (equal)
			return new SB_Param(true);
		return new SB_Param(false);
	}

	/**
	 * Tests that float parameters are properly
	 * @param p1 : float [in]
	 * @param p2 : float [out]
	 * @param p3 : float [in/out]
	 * @return boolean
	 */
	SB_Param TestFloat(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		p2.setFloat(100);

		boolean p3Value = (p3.getFloat() == 3.5);
		p3.setFloat(100);

		if ((p1.getFloat()==3.5) && p3Value)
			return new SB_Param(true);
		return new SB_Param(false);
	}

	/**
	 * Tests that integer parameters are properly
	 * @param p1 : integer [in]
	 * @param p2 : integer [out]
	 * @param p3 : integer [in/out]
	 * @return boolean
	 */
	SB_Param TestInt(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		p2.setInteger(10);

		boolean p3Value = (p3.getInteger() == -5);
		p3.setInteger(10);

		if ((p1.getInteger()==-5) && p3Value)
			return new SB_Param(true);
		return new SB_Param(false);
	}

	/**
	 * Tests returning a complex
	 * @param returnValue : string [in]
	 * @return string
	 */
	SB_Param TestReturn(SB_Param returnValue) throws SB_Exception
	{
		// your TestReturn implementation here
		return new SB_Param();
	}

	/**
	 * Tests that string parameters are properly
	 * @param p1 : string [in]
	 * @param p2 : string [out]
	 * @param p3 : string [in/out]
	 * @return boolean
	 */
	SB_Param TestString(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		p2.setString( "out" );

		boolean p3Value = false;
		if ((p3.getType() == SB_ParamType.kSB_String) && (p3.getString().compareTo("in") == 0))
			p3Value = true;

		p3.setString("out");

		if (((p1.getType() == SB_ParamType.kSB_String) && (p1.getString().compareTo("in") == 0)) && p3Value)
			return new SB_Param(true);
		return new SB_Param(false);
	}

	/**
	 * Tests that table parameters are properly
	 * @param p1 : table [in]
	 * @param p2 : table [out]
	 * @param p3 : table [in/out]
	 * @return boolean
	 */
	SB_Param TestTable(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		p2.tableSetEntry(0,0, p3.getTableEntry(1,1));
		p2.tableSetEntry(1,1, p3.getTableEntry(0,0));

		boolean p3Value = false;
		if ((p3.getTableEntry(0,0).getInteger()==1) && (p3.getTableEntry(1,1).getInteger()==4))
			p3Value = true;

		p3.tableSetEntry(0,0, p2.getTableEntry(0,0));
		p3.tableSetEntry(1,1, p2.getTableEntry(1,1));

		if (p3Value && (p1.getTableEntry(0,0).getInteger()==1) && (p1.getTableEntry(1,1).getInteger()==4))
			return new SB_Param(true);
		return new SB_Param(false);
	}

	/**
	 * Tests that vector parameters are properly
	 * @param p1 : vector [in]
	 * @param p2 : vector [out]
	 * @param p3 : vector [in/out]
	 * @return boolean
	 */
	SB_Param TestVector(SB_Param p1, SB_Param p2, SB_Param p3) throws SB_Exception
	{
		p2.setVector(-1,-2,-3);

		boolean p3Value = (p3.getVector().x == 2) && (p3.getVector().y == 3) && (p3.getVector().z == 4);
		p3.setVector(-1,-2,-3);

		if ((p1.getVector().x==2) && (p1.getVector().y==3) && (p1.getVector().z==4) && p3Value)
			return new SB_Param(true);
		return new SB_Param(false);
	}
};
